#include "c:/Opt/OpenCV2.0/include/opencv/cxcore.h"
#include "c:/Opt/OpenCV2.0/include/opencv/cxcore.h"

void* Pure_cvAlloc(unsigned int arg0)
{
  return cvAlloc(arg0);
}

void Pure_cvFree_(void* arg0)
{
  return cvFree_(arg0);
}

IplImage* Pure_cvCreateImageHeader(CvSize* arg0, int arg1, int arg2)
{
  return cvCreateImageHeader(*arg0, arg1, arg2);
}

IplImage* Pure_cvInitImageHeader(IplImage* arg0, CvSize* arg1, int arg2, int arg3, int arg4, int arg5)
{
  return cvInitImageHeader(arg0, *arg1, arg2, arg3, arg4, arg5);
}

IplImage* Pure_cvCreateImage(CvSize* arg0, int arg1, int arg2)
{
  return cvCreateImage(*arg0, arg1, arg2);
}

void Pure_cvReleaseImageHeader(IplImage** arg0)
{
  return cvReleaseImageHeader(arg0);
}

void Pure_cvReleaseImage(IplImage** arg0)
{
  return cvReleaseImage(arg0);
}

IplImage* Pure_cvCloneImage(IplImage const* arg0)
{
  return cvCloneImage(arg0);
}

void Pure_cvSetImageCOI(IplImage* arg0, int arg1)
{
  return cvSetImageCOI(arg0, arg1);
}

int Pure_cvGetImageCOI(IplImage const* arg0)
{
  return cvGetImageCOI(arg0);
}

void Pure_cvSetImageROI(IplImage* arg0, CvRect* arg1)
{
  return cvSetImageROI(arg0, *arg1);
}

void Pure_cvResetImageROI(IplImage* arg0)
{
  return cvResetImageROI(arg0);
}

CvRect* Pure_cvGetImageROI(IplImage const* arg0)
{
  static CvRect ret;
  ret = cvGetImageROI(arg0); return &ret;
}

CvMat* Pure_cvCreateMatHeader(int arg0, int arg1, int arg2)
{
  return cvCreateMatHeader(arg0, arg1, arg2);
}

CvMat* Pure_cvInitMatHeader(CvMat* arg0, int arg1, int arg2, int arg3, void* arg4, int arg5)
{
  return cvInitMatHeader(arg0, arg1, arg2, arg3, arg4, arg5);
}

CvMat* Pure_cvCreateMat(int arg0, int arg1, int arg2)
{
  return cvCreateMat(arg0, arg1, arg2);
}

void Pure_cvReleaseMat(CvMat** arg0)
{
  return cvReleaseMat(arg0);
}

CvMat* Pure_cvCloneMat(CvMat const* arg0)
{
  return cvCloneMat(arg0);
}

CvMat* Pure_cvGetSubRect(void const* arg0, CvMat* arg1, CvRect* arg2)
{
  return cvGetSubRect(arg0, arg1, *arg2);
}

CvMat* Pure_cvGetRows(void const* arg0, CvMat* arg1, int arg2, int arg3, int arg4)
{
  return cvGetRows(arg0, arg1, arg2, arg3, arg4);
}

CvMat* Pure_cvGetCols(void const* arg0, CvMat* arg1, int arg2, int arg3)
{
  return cvGetCols(arg0, arg1, arg2, arg3);
}

CvMat* Pure_cvGetDiag(void const* arg0, CvMat* arg1, int arg2)
{
  return cvGetDiag(arg0, arg1, arg2);
}

void Pure_cvScalarToRawData(CvScalar const* arg0, void* arg1, int arg2, int arg3)
{
  return cvScalarToRawData(arg0, arg1, arg2, arg3);
}

void Pure_cvRawDataToScalar(void const* arg0, int arg1, CvScalar* arg2)
{
  return cvRawDataToScalar(arg0, arg1, arg2);
}

CvMatND* Pure_cvCreateMatNDHeader(int arg0, int const* arg1, int arg2)
{
  return cvCreateMatNDHeader(arg0, arg1, arg2);
}

CvMatND* Pure_cvCreateMatND(int arg0, int const* arg1, int arg2)
{
  return cvCreateMatND(arg0, arg1, arg2);
}

CvMatND* Pure_cvInitMatNDHeader(CvMatND* arg0, int arg1, int const* arg2, int arg3, void* arg4)
{
  return cvInitMatNDHeader(arg0, arg1, arg2, arg3, arg4);
}

CvMatND* Pure_cvCloneMatND(CvMatND const* arg0)
{
  return cvCloneMatND(arg0);
}

CvSparseMat* Pure_cvCreateSparseMat(int arg0, int const* arg1, int arg2)
{
  return cvCreateSparseMat(arg0, arg1, arg2);
}

void Pure_cvReleaseSparseMat(CvSparseMat** arg0)
{
  return cvReleaseSparseMat(arg0);
}

CvSparseMat* Pure_cvCloneSparseMat(CvSparseMat const* arg0)
{
  return cvCloneSparseMat(arg0);
}

CvSparseNode* Pure_cvInitSparseMatIterator(CvSparseMat const* arg0, CvSparseMatIterator* arg1)
{
  return cvInitSparseMatIterator(arg0, arg1);
}

int Pure_cvInitNArrayIterator(int arg0, void** arg1, void const* arg2, CvMatND* arg3, CvNArrayIterator* arg4, int arg5)
{
  return cvInitNArrayIterator(arg0, arg1, arg2, arg3, arg4, arg5);
}

int Pure_cvNextNArraySlice(CvNArrayIterator* arg0)
{
  return cvNextNArraySlice(arg0);
}

int Pure_cvGetElemType(void const* arg0)
{
  return cvGetElemType(arg0);
}

int Pure_cvGetDims(void const* arg0, int* arg1)
{
  return cvGetDims(arg0, arg1);
}

int Pure_cvGetDimSize(void const* arg0, int arg1)
{
  return cvGetDimSize(arg0, arg1);
}

unsigned char* Pure_cvPtr1D(void const* arg0, int arg1, int* arg2)
{
  return cvPtr1D(arg0, arg1, arg2);
}

unsigned char* Pure_cvPtr2D(void const* arg0, int arg1, int arg2, int* arg3)
{
  return cvPtr2D(arg0, arg1, arg2, arg3);
}

unsigned char* Pure_cvPtr3D(void const* arg0, int arg1, int arg2, int arg3, int* arg4)
{
  return cvPtr3D(arg0, arg1, arg2, arg3, arg4);
}

unsigned char* Pure_cvPtrND(void const* arg0, int const* arg1, int* arg2, int arg3, unsigned int* arg4)
{
  return cvPtrND(arg0, arg1, arg2, arg3, arg4);
}

CvScalar* Pure_cvGet1D(void const* arg0, int arg1)
{
  static CvScalar ret;
  ret = cvGet1D(arg0, arg1); return &ret;
}

CvScalar* Pure_cvGet2D(void const* arg0, int arg1, int arg2)
{
  static CvScalar ret;
  ret = cvGet2D(arg0, arg1, arg2); return &ret;
}

CvScalar* Pure_cvGet3D(void const* arg0, int arg1, int arg2, int arg3)
{
  static CvScalar ret;
  ret = cvGet3D(arg0, arg1, arg2, arg3); return &ret;
}

CvScalar* Pure_cvGetND(void const* arg0, int const* arg1)
{
  static CvScalar ret;
  ret = cvGetND(arg0, arg1); return &ret;
}

double Pure_cvGetReal1D(void const* arg0, int arg1)
{
  return cvGetReal1D(arg0, arg1);
}

double Pure_cvGetReal2D(void const* arg0, int arg1, int arg2)
{
  return cvGetReal2D(arg0, arg1, arg2);
}

double Pure_cvGetReal3D(void const* arg0, int arg1, int arg2, int arg3)
{
  return cvGetReal3D(arg0, arg1, arg2, arg3);
}

double Pure_cvGetRealND(void const* arg0, int const* arg1)
{
  return cvGetRealND(arg0, arg1);
}

void Pure_cvSet1D(void* arg0, int arg1, CvScalar* arg2)
{
  return cvSet1D(arg0, arg1, *arg2);
}

void Pure_cvSet2D(void* arg0, int arg1, int arg2, CvScalar* arg3)
{
  return cvSet2D(arg0, arg1, arg2, *arg3);
}

void Pure_cvSet3D(void* arg0, int arg1, int arg2, int arg3, CvScalar* arg4)
{
  return cvSet3D(arg0, arg1, arg2, arg3, *arg4);
}

void Pure_cvSetND(void* arg0, int const* arg1, CvScalar* arg2)
{
  return cvSetND(arg0, arg1, *arg2);
}

void Pure_cvSetReal1D(void* arg0, int arg1, double arg2)
{
  return cvSetReal1D(arg0, arg1, arg2);
}

void Pure_cvSetReal2D(void* arg0, int arg1, int arg2, double arg3)
{
  return cvSetReal2D(arg0, arg1, arg2, arg3);
}

void Pure_cvSetReal3D(void* arg0, int arg1, int arg2, int arg3, double arg4)
{
  return cvSetReal3D(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvSetRealND(void* arg0, int const* arg1, double arg2)
{
  return cvSetRealND(arg0, arg1, arg2);
}

void Pure_cvClearND(void* arg0, int const* arg1)
{
  return cvClearND(arg0, arg1);
}

CvMat* Pure_cvGetMat(void const* arg0, CvMat* arg1, int* arg2, int arg3)
{
  return cvGetMat(arg0, arg1, arg2, arg3);
}

IplImage* Pure_cvGetImage(void const* arg0, IplImage* arg1)
{
  return cvGetImage(arg0, arg1);
}

void* Pure_cvReshapeMatND(void const* arg0, int arg1, void* arg2, int arg3, int arg4, int* arg5)
{
  return cvReshapeMatND(arg0, arg1, arg2, arg3, arg4, arg5);
}

CvMat* Pure_cvReshape(void const* arg0, CvMat* arg1, int arg2, int arg3)
{
  return cvReshape(arg0, arg1, arg2, arg3);
}

void Pure_cvRepeat(void const* arg0, void* arg1)
{
  return cvRepeat(arg0, arg1);
}

void Pure_cvCreateData(void* arg0)
{
  return cvCreateData(arg0);
}

void Pure_cvReleaseData(void* arg0)
{
  return cvReleaseData(arg0);
}

void Pure_cvSetData(void* arg0, void* arg1, int arg2)
{
  return cvSetData(arg0, arg1, arg2);
}

void Pure_cvGetRawData(void const* arg0, unsigned char** arg1, int* arg2, CvSize* arg3)
{
  return cvGetRawData(arg0, arg1, arg2, arg3);
}

CvSize* Pure_cvGetSize(void const* arg0)
{
  static CvSize ret;
  ret = cvGetSize(arg0); return &ret;
}

void Pure_cvCopy(void const* arg0, void* arg1, void const* arg2)
{
  return cvCopy(arg0, arg1, arg2);
}

void Pure_cvSet(void* arg0, CvScalar* arg1, void const* arg2)
{
  return cvSet(arg0, *arg1, arg2);
}

void Pure_cvSetZero(void* arg0)
{
  return cvSetZero(arg0);
}

void Pure_cvSplit(void const* arg0, void* arg1, void* arg2, void* arg3, void* arg4)
{
  return cvSplit(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvMerge(void const* arg0, void const* arg1, void const* arg2, void const* arg3, void* arg4)
{
  return cvMerge(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvMixChannels(void const** arg0, int arg1, void** arg2, int arg3, int const* arg4, int arg5)
{
  return cvMixChannels(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvConvertScale(void const* arg0, void* arg1, double arg2, double arg3)
{
  return cvConvertScale(arg0, arg1, arg2, arg3);
}

void Pure_cvConvertScaleAbs(void const* arg0, void* arg1, double arg2, double arg3)
{
  return cvConvertScaleAbs(arg0, arg1, arg2, arg3);
}

CvTermCriteria* Pure_cvCheckTermCriteria(CvTermCriteria* arg0, double arg1, int arg2)
{
  static CvTermCriteria ret;
  ret = cvCheckTermCriteria(*arg0, arg1, arg2); return &ret;
}

void Pure_cvAdd(void const* arg0, void const* arg1, void* arg2, void const* arg3)
{
  return cvAdd(arg0, arg1, arg2, arg3);
}

void Pure_cvAddS(void const* arg0, CvScalar* arg1, void* arg2, void const* arg3)
{
  return cvAddS(arg0, *arg1, arg2, arg3);
}

void Pure_cvSub(void const* arg0, void const* arg1, void* arg2, void const* arg3)
{
  return cvSub(arg0, arg1, arg2, arg3);
}

void Pure_cvSubRS(void const* arg0, CvScalar* arg1, void* arg2, void const* arg3)
{
  return cvSubRS(arg0, *arg1, arg2, arg3);
}

void Pure_cvMul(void const* arg0, void const* arg1, void* arg2, double arg3)
{
  return cvMul(arg0, arg1, arg2, arg3);
}

void Pure_cvDiv(void const* arg0, void const* arg1, void* arg2, double arg3)
{
  return cvDiv(arg0, arg1, arg2, arg3);
}

void Pure_cvScaleAdd(void const* arg0, CvScalar* arg1, void const* arg2, void* arg3)
{
  return cvScaleAdd(arg0, *arg1, arg2, arg3);
}

void Pure_cvAddWeighted(void const* arg0, double arg1, void const* arg2, double arg3, double arg4, void* arg5)
{
  return cvAddWeighted(arg0, arg1, arg2, arg3, arg4, arg5);
}

double Pure_cvDotProduct(void const* arg0, void const* arg1)
{
  return cvDotProduct(arg0, arg1);
}

void Pure_cvAnd(void const* arg0, void const* arg1, void* arg2, void const* arg3)
{
  return cvAnd(arg0, arg1, arg2, arg3);
}

void Pure_cvAndS(void const* arg0, CvScalar* arg1, void* arg2, void const* arg3)
{
  return cvAndS(arg0, *arg1, arg2, arg3);
}

void Pure_cvOr(void const* arg0, void const* arg1, void* arg2, void const* arg3)
{
  return cvOr(arg0, arg1, arg2, arg3);
}

void Pure_cvOrS(void const* arg0, CvScalar* arg1, void* arg2, void const* arg3)
{
  return cvOrS(arg0, *arg1, arg2, arg3);
}

void Pure_cvXor(void const* arg0, void const* arg1, void* arg2, void const* arg3)
{
  return cvXor(arg0, arg1, arg2, arg3);
}

void Pure_cvXorS(void const* arg0, CvScalar* arg1, void* arg2, void const* arg3)
{
  return cvXorS(arg0, *arg1, arg2, arg3);
}

void Pure_cvNot(void const* arg0, void* arg1)
{
  return cvNot(arg0, arg1);
}

void Pure_cvInRange(void const* arg0, void const* arg1, void const* arg2, void* arg3)
{
  return cvInRange(arg0, arg1, arg2, arg3);
}

void Pure_cvInRangeS(void const* arg0, CvScalar* arg1, CvScalar* arg2, void* arg3)
{
  return cvInRangeS(arg0, *arg1, *arg2, arg3);
}

void Pure_cvCmp(void const* arg0, void const* arg1, void* arg2, int arg3)
{
  return cvCmp(arg0, arg1, arg2, arg3);
}

void Pure_cvCmpS(void const* arg0, double arg1, void* arg2, int arg3)
{
  return cvCmpS(arg0, arg1, arg2, arg3);
}

void Pure_cvMin(void const* arg0, void const* arg1, void* arg2)
{
  return cvMin(arg0, arg1, arg2);
}

void Pure_cvMax(void const* arg0, void const* arg1, void* arg2)
{
  return cvMax(arg0, arg1, arg2);
}

void Pure_cvMinS(void const* arg0, double arg1, void* arg2)
{
  return cvMinS(arg0, arg1, arg2);
}

void Pure_cvMaxS(void const* arg0, double arg1, void* arg2)
{
  return cvMaxS(arg0, arg1, arg2);
}

void Pure_cvAbsDiff(void const* arg0, void const* arg1, void* arg2)
{
  return cvAbsDiff(arg0, arg1, arg2);
}

void Pure_cvAbsDiffS(void const* arg0, void* arg1, CvScalar* arg2)
{
  return cvAbsDiffS(arg0, arg1, *arg2);
}

void Pure_cvCartToPolar(void const* arg0, void const* arg1, void* arg2, void* arg3, int arg4)
{
  return cvCartToPolar(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvPolarToCart(void const* arg0, void const* arg1, void* arg2, void* arg3, int arg4)
{
  return cvPolarToCart(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvPow(void const* arg0, void* arg1, double arg2)
{
  return cvPow(arg0, arg1, arg2);
}

void Pure_cvExp(void const* arg0, void* arg1)
{
  return cvExp(arg0, arg1);
}

void Pure_cvLog(void const* arg0, void* arg1)
{
  return cvLog(arg0, arg1);
}

float Pure_cvFastArctan(float arg0, float arg1)
{
  return cvFastArctan(arg0, arg1);
}

float Pure_cvCbrt(float arg0)
{
  return cvCbrt(arg0);
}

int Pure_cvCheckArr(void const* arg0, int arg1, double arg2, double arg3)
{
  return cvCheckArr(arg0, arg1, arg2, arg3);
}

void Pure_cvRandArr(unsigned long long* arg0, void* arg1, int arg2, CvScalar* arg3, CvScalar* arg4)
{
  return cvRandArr(arg0, arg1, arg2, *arg3, *arg4);
}

void Pure_cvRandShuffle(void* arg0, unsigned long long* arg1, double arg2)
{
  return cvRandShuffle(arg0, arg1, arg2);
}

void Pure_cvSort(void const* arg0, void* arg1, void* arg2, int arg3)
{
  return cvSort(arg0, arg1, arg2, arg3);
}

int Pure_cvSolveCubic(CvMat const* arg0, CvMat* arg1)
{
  return cvSolveCubic(arg0, arg1);
}

void Pure_cvSolvePoly(CvMat const* arg0, CvMat* arg1, int arg2, int arg3)
{
  return cvSolvePoly(arg0, arg1, arg2, arg3);
}

void Pure_cvCrossProduct(void const* arg0, void const* arg1, void* arg2)
{
  return cvCrossProduct(arg0, arg1, arg2);
}

void Pure_cvGEMM(void const* arg0, void const* arg1, double arg2, void const* arg3, double arg4, void* arg5, int arg6)
{
  return cvGEMM(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvTransform(void const* arg0, void* arg1, CvMat const* arg2, CvMat const* arg3)
{
  return cvTransform(arg0, arg1, arg2, arg3);
}

void Pure_cvPerspectiveTransform(void const* arg0, void* arg1, CvMat const* arg2)
{
  return cvPerspectiveTransform(arg0, arg1, arg2);
}

void Pure_cvMulTransposed(void const* arg0, void* arg1, int arg2, void const* arg3, double arg4)
{
  return cvMulTransposed(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvTranspose(void const* arg0, void* arg1)
{
  return cvTranspose(arg0, arg1);
}

void Pure_cvCompleteSymm(CvMat* arg0, int arg1)
{
  return cvCompleteSymm(arg0, arg1);
}

void Pure_cvFlip(void const* arg0, void* arg1, int arg2)
{
  return cvFlip(arg0, arg1, arg2);
}

void Pure_cvSVD(void* arg0, void* arg1, void* arg2, void* arg3, int arg4)
{
  return cvSVD(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvSVBkSb(void const* arg0, void const* arg1, void const* arg2, void const* arg3, void* arg4, int arg5)
{
  return cvSVBkSb(arg0, arg1, arg2, arg3, arg4, arg5);
}

double Pure_cvInvert(void const* arg0, void* arg1, int arg2)
{
  return cvInvert(arg0, arg1, arg2);
}

int Pure_cvSolve(void const* arg0, void const* arg1, void* arg2, int arg3)
{
  return cvSolve(arg0, arg1, arg2, arg3);
}

double Pure_cvDet(void const* arg0)
{
  return cvDet(arg0);
}

CvScalar* Pure_cvTrace(void const* arg0)
{
  static CvScalar ret;
  ret = cvTrace(arg0); return &ret;
}

void Pure_cvEigenVV(void* arg0, void* arg1, void* arg2, double arg3, int arg4, int arg5)
{
  return cvEigenVV(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvSetIdentity(void* arg0, CvScalar* arg1)
{
  return cvSetIdentity(arg0, *arg1);
}

void* Pure_cvRange(void* arg0, double arg1, double arg2)
{
  return cvRange(arg0, arg1, arg2);
}

void Pure_cvCalcCovarMatrix(void const** arg0, int arg1, void* arg2, void* arg3, int arg4)
{
  return cvCalcCovarMatrix(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvCalcPCA(void const* arg0, void* arg1, void* arg2, void* arg3, int arg4)
{
  return cvCalcPCA(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvProjectPCA(void const* arg0, void const* arg1, void const* arg2, void* arg3)
{
  return cvProjectPCA(arg0, arg1, arg2, arg3);
}

void Pure_cvBackProjectPCA(void const* arg0, void const* arg1, void const* arg2, void* arg3)
{
  return cvBackProjectPCA(arg0, arg1, arg2, arg3);
}

double Pure_cvMahalanobis(void const* arg0, void const* arg1, void const* arg2)
{
  return cvMahalanobis(arg0, arg1, arg2);
}

CvScalar* Pure_cvSum(void const* arg0)
{
  static CvScalar ret;
  ret = cvSum(arg0); return &ret;
}

int Pure_cvCountNonZero(void const* arg0)
{
  return cvCountNonZero(arg0);
}

CvScalar* Pure_cvAvg(void const* arg0, void const* arg1)
{
  static CvScalar ret;
  ret = cvAvg(arg0, arg1); return &ret;
}

void Pure_cvAvgSdv(void const* arg0, CvScalar* arg1, CvScalar* arg2, void const* arg3)
{
  return cvAvgSdv(arg0, arg1, arg2, arg3);
}

void Pure_cvMinMaxLoc(void const* arg0, double* arg1, double* arg2, CvPoint* arg3, CvPoint* arg4, void const* arg5)
{
  return cvMinMaxLoc(arg0, arg1, arg2, arg3, arg4, arg5);
}

double Pure_cvNorm(void const* arg0, void const* arg1, int arg2, void const* arg3)
{
  return cvNorm(arg0, arg1, arg2, arg3);
}

void Pure_cvNormalize(void const* arg0, void* arg1, double arg2, double arg3, int arg4, void const* arg5)
{
  return cvNormalize(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvReduce(void const* arg0, void* arg1, int arg2, int arg3)
{
  return cvReduce(arg0, arg1, arg2, arg3);
}

void Pure_cvDFT(void const* arg0, void* arg1, int arg2, int arg3)
{
  return cvDFT(arg0, arg1, arg2, arg3);
}

void Pure_cvMulSpectrums(void const* arg0, void const* arg1, void* arg2, int arg3)
{
  return cvMulSpectrums(arg0, arg1, arg2, arg3);
}

int Pure_cvGetOptimalDFTSize(int arg0)
{
  return cvGetOptimalDFTSize(arg0);
}

void Pure_cvDCT(void const* arg0, void* arg1, int arg2)
{
  return cvDCT(arg0, arg1, arg2);
}

int Pure_cvSliceLength(CvSlice* arg0, CvSeq const* arg1)
{
  return cvSliceLength(*arg0, arg1);
}

CvMemStorage* Pure_cvCreateMemStorage(int arg0)
{
  return cvCreateMemStorage(arg0);
}

CvMemStorage* Pure_cvCreateChildMemStorage(CvMemStorage* arg0)
{
  return cvCreateChildMemStorage(arg0);
}

void Pure_cvReleaseMemStorage(CvMemStorage** arg0)
{
  return cvReleaseMemStorage(arg0);
}

void Pure_cvClearMemStorage(CvMemStorage* arg0)
{
  return cvClearMemStorage(arg0);
}

void Pure_cvSaveMemStoragePos(CvMemStorage const* arg0, CvMemStoragePos* arg1)
{
  return cvSaveMemStoragePos(arg0, arg1);
}

void Pure_cvRestoreMemStoragePos(CvMemStorage* arg0, CvMemStoragePos* arg1)
{
  return cvRestoreMemStoragePos(arg0, arg1);
}

void* Pure_cvMemStorageAlloc(CvMemStorage* arg0, unsigned int arg1)
{
  return cvMemStorageAlloc(arg0, arg1);
}

CvString* Pure_cvMemStorageAllocString(CvMemStorage* arg0, char const* arg1, int arg2)
{
  static CvString ret;
  ret = cvMemStorageAllocString(arg0, arg1, arg2); return &ret;
}

CvSeq* Pure_cvCreateSeq(int arg0, int arg1, int arg2, CvMemStorage* arg3)
{
  return cvCreateSeq(arg0, arg1, arg2, arg3);
}

void Pure_cvSetSeqBlockSize(CvSeq* arg0, int arg1)
{
  return cvSetSeqBlockSize(arg0, arg1);
}

char* Pure_cvSeqPush(CvSeq* arg0, void const* arg1)
{
  return cvSeqPush(arg0, arg1);
}

char* Pure_cvSeqPushFront(CvSeq* arg0, void const* arg1)
{
  return cvSeqPushFront(arg0, arg1);
}

void Pure_cvSeqPop(CvSeq* arg0, void* arg1)
{
  return cvSeqPop(arg0, arg1);
}

void Pure_cvSeqPopFront(CvSeq* arg0, void* arg1)
{
  return cvSeqPopFront(arg0, arg1);
}

void Pure_cvSeqPushMulti(CvSeq* arg0, void const* arg1, int arg2, int arg3)
{
  return cvSeqPushMulti(arg0, arg1, arg2, arg3);
}

void Pure_cvSeqPopMulti(CvSeq* arg0, void* arg1, int arg2, int arg3)
{
  return cvSeqPopMulti(arg0, arg1, arg2, arg3);
}

char* Pure_cvSeqInsert(CvSeq* arg0, int arg1, void const* arg2)
{
  return cvSeqInsert(arg0, arg1, arg2);
}

void Pure_cvSeqRemove(CvSeq* arg0, int arg1)
{
  return cvSeqRemove(arg0, arg1);
}

void Pure_cvClearSeq(CvSeq* arg0)
{
  return cvClearSeq(arg0);
}

char* Pure_cvGetSeqElem(CvSeq const* arg0, int arg1)
{
  return cvGetSeqElem(arg0, arg1);
}

int Pure_cvSeqElemIdx(CvSeq const* arg0, void const* arg1, CvSeqBlock** arg2)
{
  return cvSeqElemIdx(arg0, arg1, arg2);
}

void Pure_cvStartAppendToSeq(CvSeq* arg0, CvSeqWriter* arg1)
{
  return cvStartAppendToSeq(arg0, arg1);
}

void Pure_cvStartWriteSeq(int arg0, int arg1, int arg2, CvMemStorage* arg3, CvSeqWriter* arg4)
{
  return cvStartWriteSeq(arg0, arg1, arg2, arg3, arg4);
}

CvSeq* Pure_cvEndWriteSeq(CvSeqWriter* arg0)
{
  return cvEndWriteSeq(arg0);
}

void Pure_cvFlushSeqWriter(CvSeqWriter* arg0)
{
  return cvFlushSeqWriter(arg0);
}

void Pure_cvStartReadSeq(CvSeq const* arg0, CvSeqReader* arg1, int arg2)
{
  return cvStartReadSeq(arg0, arg1, arg2);
}

int Pure_cvGetSeqReaderPos(CvSeqReader* arg0)
{
  return cvGetSeqReaderPos(arg0);
}

void Pure_cvSetSeqReaderPos(CvSeqReader* arg0, int arg1, int arg2)
{
  return cvSetSeqReaderPos(arg0, arg1, arg2);
}

void* Pure_cvCvtSeqToArray(CvSeq const* arg0, void* arg1, CvSlice* arg2)
{
  return cvCvtSeqToArray(arg0, arg1, *arg2);
}

CvSeq* Pure_cvMakeSeqHeaderForArray(int arg0, int arg1, int arg2, void* arg3, int arg4, CvSeq* arg5, CvSeqBlock* arg6)
{
  return cvMakeSeqHeaderForArray(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

CvSeq* Pure_cvSeqSlice(CvSeq const* arg0, CvSlice* arg1, CvMemStorage* arg2, int arg3)
{
  return cvSeqSlice(arg0, *arg1, arg2, arg3);
}

void Pure_cvSeqRemoveSlice(CvSeq* arg0, CvSlice* arg1)
{
  return cvSeqRemoveSlice(arg0, *arg1);
}

void Pure_cvSeqInsertSlice(CvSeq* arg0, int arg1, void const* arg2)
{
  return cvSeqInsertSlice(arg0, arg1, arg2);
}

void Pure_cvSeqSort(CvSeq* arg0, void* arg1, void* arg2)
{
  return cvSeqSort(arg0, arg1, arg2);
}

char* Pure_cvSeqSearch(CvSeq* arg0, void const* arg1, void* arg2, int arg3, int* arg4, void* arg5)
{
  return cvSeqSearch(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvSeqInvert(CvSeq* arg0)
{
  return cvSeqInvert(arg0);
}

int Pure_cvSeqPartition(CvSeq const* arg0, CvMemStorage* arg1, CvSeq** arg2, void* arg3, void* arg4)
{
  return cvSeqPartition(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvChangeSeqBlock(void* arg0, int arg1)
{
  return cvChangeSeqBlock(arg0, arg1);
}

void Pure_cvCreateSeqBlock(CvSeqWriter* arg0)
{
  return cvCreateSeqBlock(arg0);
}

CvSet* Pure_cvCreateSet(int arg0, int arg1, int arg2, CvMemStorage* arg3)
{
  return cvCreateSet(arg0, arg1, arg2, arg3);
}

int Pure_cvSetAdd(CvSet* arg0, CvSetElem* arg1, CvSetElem** arg2)
{
  return cvSetAdd(arg0, arg1, arg2);
}

void Pure_cvSetRemove(CvSet* arg0, int arg1)
{
  return cvSetRemove(arg0, arg1);
}

void Pure_cvClearSet(CvSet* arg0)
{
  return cvClearSet(arg0);
}

CvGraph* Pure_cvCreateGraph(int arg0, int arg1, int arg2, int arg3, CvMemStorage* arg4)
{
  return cvCreateGraph(arg0, arg1, arg2, arg3, arg4);
}

int Pure_cvGraphAddVtx(CvGraph* arg0, CvGraphVtx const* arg1, CvGraphVtx** arg2)
{
  return cvGraphAddVtx(arg0, arg1, arg2);
}

int Pure_cvGraphRemoveVtx(CvGraph* arg0, int arg1)
{
  return cvGraphRemoveVtx(arg0, arg1);
}

int Pure_cvGraphRemoveVtxByPtr(CvGraph* arg0, CvGraphVtx* arg1)
{
  return cvGraphRemoveVtxByPtr(arg0, arg1);
}

int Pure_cvGraphAddEdge(CvGraph* arg0, int arg1, int arg2, CvGraphEdge const* arg3, CvGraphEdge** arg4)
{
  return cvGraphAddEdge(arg0, arg1, arg2, arg3, arg4);
}

int Pure_cvGraphAddEdgeByPtr(CvGraph* arg0, CvGraphVtx* arg1, CvGraphVtx* arg2, CvGraphEdge const* arg3, CvGraphEdge** arg4)
{
  return cvGraphAddEdgeByPtr(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvGraphRemoveEdge(CvGraph* arg0, int arg1, int arg2)
{
  return cvGraphRemoveEdge(arg0, arg1, arg2);
}

void Pure_cvGraphRemoveEdgeByPtr(CvGraph* arg0, CvGraphVtx* arg1, CvGraphVtx* arg2)
{
  return cvGraphRemoveEdgeByPtr(arg0, arg1, arg2);
}

CvGraphEdge* Pure_cvFindGraphEdge(CvGraph const* arg0, int arg1, int arg2)
{
  return cvFindGraphEdge(arg0, arg1, arg2);
}

CvGraphEdge* Pure_cvFindGraphEdgeByPtr(CvGraph const* arg0, CvGraphVtx const* arg1, CvGraphVtx const* arg2)
{
  return cvFindGraphEdgeByPtr(arg0, arg1, arg2);
}

void Pure_cvClearGraph(CvGraph* arg0)
{
  return cvClearGraph(arg0);
}

int Pure_cvGraphVtxDegree(CvGraph const* arg0, int arg1)
{
  return cvGraphVtxDegree(arg0, arg1);
}

int Pure_cvGraphVtxDegreeByPtr(CvGraph const* arg0, CvGraphVtx const* arg1)
{
  return cvGraphVtxDegreeByPtr(arg0, arg1);
}

CvGraphScanner* Pure_cvCreateGraphScanner(CvGraph* arg0, CvGraphVtx* arg1, int arg2)
{
  return cvCreateGraphScanner(arg0, arg1, arg2);
}

void Pure_cvReleaseGraphScanner(CvGraphScanner** arg0)
{
  return cvReleaseGraphScanner(arg0);
}

int Pure_cvNextGraphItem(CvGraphScanner* arg0)
{
  return cvNextGraphItem(arg0);
}

CvGraph* Pure_cvCloneGraph(CvGraph const* arg0, CvMemStorage* arg1)
{
  return cvCloneGraph(arg0, arg1);
}

void Pure_cvLine(void* arg0, CvPoint* arg1, CvPoint* arg2, CvScalar* arg3, int arg4, int arg5, int arg6)
{
  return cvLine(arg0, *arg1, *arg2, *arg3, arg4, arg5, arg6);
}

void Pure_cvRectangle(void* arg0, CvPoint* arg1, CvPoint* arg2, CvScalar* arg3, int arg4, int arg5, int arg6)
{
  return cvRectangle(arg0, *arg1, *arg2, *arg3, arg4, arg5, arg6);
}

void Pure_cvCircle(void* arg0, CvPoint* arg1, int arg2, CvScalar* arg3, int arg4, int arg5, int arg6)
{
  return cvCircle(arg0, *arg1, arg2, *arg3, arg4, arg5, arg6);
}

void Pure_cvEllipse(void* arg0, CvPoint* arg1, CvSize* arg2, double arg3, double arg4, double arg5, CvScalar* arg6, int arg7, int arg8, int arg9)
{
  return cvEllipse(arg0, *arg1, *arg2, arg3, arg4, arg5, *arg6, arg7, arg8, arg9);
}

void Pure_cvFillConvexPoly(void* arg0, CvPoint const* arg1, int arg2, CvScalar* arg3, int arg4, int arg5)
{
  return cvFillConvexPoly(arg0, arg1, arg2, *arg3, arg4, arg5);
}

void Pure_cvFillPoly(void* arg0, CvPoint** arg1, int const* arg2, int arg3, CvScalar* arg4, int arg5, int arg6)
{
  return cvFillPoly(arg0, arg1, arg2, arg3, *arg4, arg5, arg6);
}

void Pure_cvPolyLine(void* arg0, CvPoint** arg1, int const* arg2, int arg3, int arg4, CvScalar* arg5, int arg6, int arg7, int arg8)
{
  return cvPolyLine(arg0, arg1, arg2, arg3, arg4, *arg5, arg6, arg7, arg8);
}

int Pure_cvClipLine(CvSize* arg0, CvPoint* arg1, CvPoint* arg2)
{
  return cvClipLine(*arg0, arg1, arg2);
}

int Pure_cvInitLineIterator(void const* arg0, CvPoint* arg1, CvPoint* arg2, CvLineIterator* arg3, int arg4, int arg5)
{
  return cvInitLineIterator(arg0, *arg1, *arg2, arg3, arg4, arg5);
}

void Pure_cvInitFont(CvFont* arg0, int arg1, double arg2, double arg3, double arg4, int arg5, int arg6)
{
  return cvInitFont(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvPutText(void* arg0, char const* arg1, CvPoint* arg2, CvFont const* arg3, CvScalar* arg4)
{
  return cvPutText(arg0, arg1, *arg2, arg3, *arg4);
}

void Pure_cvGetTextSize(char const* arg0, CvFont const* arg1, CvSize* arg2, int* arg3)
{
  return cvGetTextSize(arg0, arg1, arg2, arg3);
}

CvScalar* Pure_cvColorToScalar(double arg0, int arg1)
{
  static CvScalar ret;
  ret = cvColorToScalar(arg0, arg1); return &ret;
}

int Pure_cvEllipse2Poly(CvPoint* arg0, CvSize* arg1, int arg2, int arg3, int arg4, CvPoint* arg5, int arg6)
{
  return cvEllipse2Poly(*arg0, *arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvDrawContours(void* arg0, CvSeq* arg1, CvScalar* arg2, CvScalar* arg3, int arg4, int arg5, int arg6, CvPoint* arg7)
{
  return cvDrawContours(arg0, arg1, *arg2, *arg3, arg4, arg5, arg6, *arg7);
}

void Pure_cvLUT(void const* arg0, void* arg1, void const* arg2)
{
  return cvLUT(arg0, arg1, arg2);
}

void Pure_cvInitTreeNodeIterator(CvTreeNodeIterator* arg0, void const* arg1, int arg2)
{
  return cvInitTreeNodeIterator(arg0, arg1, arg2);
}

void* Pure_cvNextTreeNode(CvTreeNodeIterator* arg0)
{
  return cvNextTreeNode(arg0);
}

void* Pure_cvPrevTreeNode(CvTreeNodeIterator* arg0)
{
  return cvPrevTreeNode(arg0);
}

void Pure_cvInsertNodeIntoTree(void* arg0, void* arg1, void* arg2)
{
  return cvInsertNodeIntoTree(arg0, arg1, arg2);
}

void Pure_cvRemoveNodeFromTree(void* arg0, void* arg1)
{
  return cvRemoveNodeFromTree(arg0, arg1);
}

CvSeq* Pure_cvTreeToNodeSeq(void const* arg0, int arg1, CvMemStorage* arg2)
{
  return cvTreeToNodeSeq(arg0, arg1, arg2);
}

int Pure_cvKMeans2(void const* arg0, int arg1, void* arg2, CvTermCriteria* arg3, int arg4, unsigned long long* arg5, int arg6, void* arg7, double* arg8)
{
  return cvKMeans2(arg0, arg1, arg2, *arg3, arg4, arg5, arg6, arg7, arg8);
}

int Pure_cvRegisterModule(CvModuleInfo const* arg0)
{
  return cvRegisterModule(arg0);
}

int Pure_cvUseOptimized(int arg0)
{
  return cvUseOptimized(arg0);
}

void Pure_cvGetModuleInfo(char const* arg0, char const** arg1, char const** arg2)
{
  return cvGetModuleInfo(arg0, arg1, arg2);
}

int Pure_cvGetErrStatus()
{
  return cvGetErrStatus();
}

void Pure_cvSetErrStatus(int arg0)
{
  return cvSetErrStatus(arg0);
}

int Pure_cvGetErrMode()
{
  return cvGetErrMode();
}

int Pure_cvSetErrMode(int arg0)
{
  return cvSetErrMode(arg0);
}

void Pure_cvError(int arg0, char const* arg1, char const* arg2, char const* arg3, int arg4)
{
  return cvError(arg0, arg1, arg2, arg3, arg4);
}

char const* Pure_cvErrorStr(int arg0)
{
  return cvErrorStr(arg0);
}

int Pure_cvGetErrInfo(char const** arg0, char const** arg1, char const** arg2, int* arg3)
{
  return cvGetErrInfo(arg0, arg1, arg2, arg3);
}

int Pure_cvErrorFromIppStatus(int arg0)
{
  return cvErrorFromIppStatus(arg0);
}

void* Pure_cvRedirectError(void* arg0, void* arg1, void** arg2)
{
  return cvRedirectError(arg0, arg1, arg2);
}

int Pure_cvNulDevReport(int arg0, char const* arg1, char const* arg2, char const* arg3, int arg4, void* arg5)
{
  return cvNulDevReport(arg0, arg1, arg2, arg3, arg4, arg5);
}

int Pure_cvStdErrReport(int arg0, char const* arg1, char const* arg2, char const* arg3, int arg4, void* arg5)
{
  return cvStdErrReport(arg0, arg1, arg2, arg3, arg4, arg5);
}

int Pure_cvGuiBoxReport(int arg0, char const* arg1, char const* arg2, char const* arg3, int arg4, void* arg5)
{
  return cvGuiBoxReport(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvSetMemoryManager(void* arg0, void* arg1, void* arg2)
{
  return cvSetMemoryManager(arg0, arg1, arg2);
}

void Pure_cvSetIPLAllocators(void* arg0, void* arg1, void* arg2, void* arg3, void* arg4)
{
  return cvSetIPLAllocators(arg0, arg1, arg2, arg3, arg4);
}

CvFileStorage* Pure_cvOpenFileStorage(char const* arg0, CvMemStorage* arg1, int arg2)
{
  return cvOpenFileStorage(arg0, arg1, arg2);
}

void Pure_cvReleaseFileStorage(CvFileStorage** arg0)
{
  return cvReleaseFileStorage(arg0);
}

char const* Pure_cvAttrValue(CvAttrList const* arg0, char const* arg1)
{
  return cvAttrValue(arg0, arg1);
}

void Pure_cvStartWriteStruct(CvFileStorage* arg0, char const* arg1, int arg2, char const* arg3, CvAttrList* arg4)
{
  return cvStartWriteStruct(arg0, arg1, arg2, arg3, *arg4);
}

void Pure_cvEndWriteStruct(CvFileStorage* arg0)
{
  return cvEndWriteStruct(arg0);
}

void Pure_cvWriteInt(CvFileStorage* arg0, char const* arg1, int arg2)
{
  return cvWriteInt(arg0, arg1, arg2);
}

void Pure_cvWriteReal(CvFileStorage* arg0, char const* arg1, double arg2)
{
  return cvWriteReal(arg0, arg1, arg2);
}

void Pure_cvWriteString(CvFileStorage* arg0, char const* arg1, char const* arg2, int arg3)
{
  return cvWriteString(arg0, arg1, arg2, arg3);
}

void Pure_cvWriteComment(CvFileStorage* arg0, char const* arg1, int arg2)
{
  return cvWriteComment(arg0, arg1, arg2);
}

void Pure_cvWrite(CvFileStorage* arg0, char const* arg1, void const* arg2, CvAttrList* arg3)
{
  return cvWrite(arg0, arg1, arg2, *arg3);
}

void Pure_cvStartNextStream(CvFileStorage* arg0)
{
  return cvStartNextStream(arg0);
}

void Pure_cvWriteRawData(CvFileStorage* arg0, void const* arg1, int arg2, char const* arg3)
{
  return cvWriteRawData(arg0, arg1, arg2, arg3);
}

CvStringHashNode* Pure_cvGetHashedKey(CvFileStorage* arg0, char const* arg1, int arg2, int arg3)
{
  return cvGetHashedKey(arg0, arg1, arg2, arg3);
}

CvFileNode* Pure_cvGetRootFileNode(CvFileStorage const* arg0, int arg1)
{
  return cvGetRootFileNode(arg0, arg1);
}

CvFileNode* Pure_cvGetFileNode(CvFileStorage* arg0, CvFileNode* arg1, CvStringHashNode const* arg2, int arg3)
{
  return cvGetFileNode(arg0, arg1, arg2, arg3);
}

CvFileNode* Pure_cvGetFileNodeByName(CvFileStorage const* arg0, CvFileNode const* arg1, char const* arg2)
{
  return cvGetFileNodeByName(arg0, arg1, arg2);
}

void* Pure_cvRead(CvFileStorage* arg0, CvFileNode* arg1, CvAttrList* arg2)
{
  return cvRead(arg0, arg1, arg2);
}

void Pure_cvStartReadRawData(CvFileStorage const* arg0, CvFileNode const* arg1, CvSeqReader* arg2)
{
  return cvStartReadRawData(arg0, arg1, arg2);
}

void Pure_cvReadRawDataSlice(CvFileStorage const* arg0, CvSeqReader* arg1, int arg2, void* arg3, char const* arg4)
{
  return cvReadRawDataSlice(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvReadRawData(CvFileStorage const* arg0, CvFileNode const* arg1, void* arg2, char const* arg3)
{
  return cvReadRawData(arg0, arg1, arg2, arg3);
}

void Pure_cvWriteFileNode(CvFileStorage* arg0, char const* arg1, CvFileNode const* arg2, int arg3)
{
  return cvWriteFileNode(arg0, arg1, arg2, arg3);
}

char const* Pure_cvGetFileNodeName(CvFileNode const* arg0)
{
  return cvGetFileNodeName(arg0);
}

void Pure_cvRegisterType(CvTypeInfo const* arg0)
{
  return cvRegisterType(arg0);
}

void Pure_cvUnregisterType(char const* arg0)
{
  return cvUnregisterType(arg0);
}

CvTypeInfo* Pure_cvFirstType()
{
  return cvFirstType();
}

CvTypeInfo* Pure_cvFindType(char const* arg0)
{
  return cvFindType(arg0);
}

CvTypeInfo* Pure_cvTypeOf(void const* arg0)
{
  return cvTypeOf(arg0);
}

void Pure_cvRelease(void** arg0)
{
  return cvRelease(arg0);
}

void* Pure_cvClone(void const* arg0)
{
  return cvClone(arg0);
}

void Pure_cvSave(char const* arg0, void const* arg1, char const* arg2, char const* arg3, CvAttrList* arg4)
{
  return cvSave(arg0, arg1, arg2, arg3, *arg4);
}

void* Pure_cvLoad(char const* arg0, CvMemStorage* arg1, char const* arg2, char const** arg3)
{
  return cvLoad(arg0, arg1, arg2, arg3);
}

long long Pure_cvGetTickCount()
{
  return cvGetTickCount();
}

double Pure_cvGetTickFrequency()
{
  return cvGetTickFrequency();
}

int Pure_cvGetNumThreads()
{
  return cvGetNumThreads();
}

void Pure_cvSetNumThreads(int arg0)
{
  return cvSetNumThreads(arg0);
}

int Pure_cvGetThreadNum()
{
  return cvGetThreadNum();
}

int Pure_cvSetImageIOFunctions(void* arg0, void* arg1, void* arg2, void* arg3)
{
  return cvSetImageIOFunctions(arg0, arg1, arg2, arg3);
}
#include "c:/Opt/OpenCV2.0/include/opencv/cv.h"
#include "c:/Opt/OpenCV2.0/include/opencv/cv.h"

void Pure_cvCopyMakeBorder(void const* arg0, void* arg1, CvPoint* arg2, int arg3, CvScalar* arg4)
{
  return cvCopyMakeBorder(arg0, arg1, *arg2, arg3, *arg4);
}

void Pure_cvSmooth(void const* arg0, void* arg1, int arg2, int arg3, int arg4, double arg5, double arg6)
{
  return cvSmooth(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvFilter2D(void const* arg0, void* arg1, CvMat const* arg2, CvPoint* arg3)
{
  return cvFilter2D(arg0, arg1, arg2, *arg3);
}

void Pure_cvIntegral(void const* arg0, void* arg1, void* arg2, void* arg3)
{
  return cvIntegral(arg0, arg1, arg2, arg3);
}

void Pure_cvPyrDown(void const* arg0, void* arg1, int arg2)
{
  return cvPyrDown(arg0, arg1, arg2);
}

void Pure_cvPyrUp(void const* arg0, void* arg1, int arg2)
{
  return cvPyrUp(arg0, arg1, arg2);
}

CvMat** Pure_cvCreatePyramid(void const* arg0, int arg1, double arg2, CvSize const* arg3, void* arg4, int arg5, int arg6)
{
  return cvCreatePyramid(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvReleasePyramid(CvMat*** arg0, int arg1)
{
  return cvReleasePyramid(arg0, arg1);
}

void Pure_cvPyrSegmentation(IplImage* arg0, IplImage* arg1, CvMemStorage* arg2, CvSeq** arg3, int arg4, double arg5, double arg6)
{
  return cvPyrSegmentation(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvPyrMeanShiftFiltering(void const* arg0, void* arg1, double arg2, double arg3, int arg4, CvTermCriteria* arg5)
{
  return cvPyrMeanShiftFiltering(arg0, arg1, arg2, arg3, arg4, *arg5);
}

void Pure_cvWatershed(void const* arg0, void* arg1)
{
  return cvWatershed(arg0, arg1);
}

void Pure_cvInpaint(void const* arg0, void const* arg1, void* arg2, double arg3, int arg4)
{
  return cvInpaint(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvSobel(void const* arg0, void* arg1, int arg2, int arg3, int arg4)
{
  return cvSobel(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvLaplace(void const* arg0, void* arg1, int arg2)
{
  return cvLaplace(arg0, arg1, arg2);
}

void Pure_cvCvtColor(void const* arg0, void* arg1, int arg2)
{
  return cvCvtColor(arg0, arg1, arg2);
}

void Pure_cvResize(void const* arg0, void* arg1, int arg2)
{
  return cvResize(arg0, arg1, arg2);
}

void Pure_cvWarpAffine(void const* arg0, void* arg1, CvMat const* arg2, int arg3, CvScalar* arg4)
{
  return cvWarpAffine(arg0, arg1, arg2, arg3, *arg4);
}

CvMat* Pure_cvGetAffineTransform(CvPoint2D32f const* arg0, CvPoint2D32f const* arg1, CvMat* arg2)
{
  return cvGetAffineTransform(arg0, arg1, arg2);
}

void Pure_cvWarpPerspective(void const* arg0, void* arg1, CvMat const* arg2, int arg3, CvScalar* arg4)
{
  return cvWarpPerspective(arg0, arg1, arg2, arg3, *arg4);
}

CvMat* Pure_cvGetPerspectiveTransform(CvPoint2D32f const* arg0, CvPoint2D32f const* arg1, CvMat* arg2)
{
  return cvGetPerspectiveTransform(arg0, arg1, arg2);
}

void Pure_cvRemap(void const* arg0, void* arg1, void const* arg2, void const* arg3, int arg4, CvScalar* arg5)
{
  return cvRemap(arg0, arg1, arg2, arg3, arg4, *arg5);
}

void Pure_cvConvertMaps(void const* arg0, void const* arg1, void* arg2, void* arg3)
{
  return cvConvertMaps(arg0, arg1, arg2, arg3);
}

void Pure_cvLogPolar(void const* arg0, void* arg1, CvPoint2D32f* arg2, double arg3, int arg4)
{
  return cvLogPolar(arg0, arg1, *arg2, arg3, arg4);
}

void Pure_cvLinearPolar(void const* arg0, void* arg1, CvPoint2D32f* arg2, double arg3, int arg4)
{
  return cvLinearPolar(arg0, arg1, *arg2, arg3, arg4);
}

IplConvKernel* Pure_cvCreateStructuringElementEx(int arg0, int arg1, int arg2, int arg3, int arg4, int* arg5)
{
  return cvCreateStructuringElementEx(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvReleaseStructuringElement(IplConvKernel** arg0)
{
  return cvReleaseStructuringElement(arg0);
}

void Pure_cvErode(void const* arg0, void* arg1, IplConvKernel* arg2, int arg3)
{
  return cvErode(arg0, arg1, arg2, arg3);
}

void Pure_cvDilate(void const* arg0, void* arg1, IplConvKernel* arg2, int arg3)
{
  return cvDilate(arg0, arg1, arg2, arg3);
}

void Pure_cvMorphologyEx(void const* arg0, void* arg1, void* arg2, IplConvKernel* arg3, int arg4, int arg5)
{
  return cvMorphologyEx(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvMoments(void const* arg0, CvMoments* arg1, int arg2)
{
  return cvMoments(arg0, arg1, arg2);
}

double Pure_cvGetSpatialMoment(CvMoments* arg0, int arg1, int arg2)
{
  return cvGetSpatialMoment(arg0, arg1, arg2);
}

double Pure_cvGetCentralMoment(CvMoments* arg0, int arg1, int arg2)
{
  return cvGetCentralMoment(arg0, arg1, arg2);
}

double Pure_cvGetNormalizedCentralMoment(CvMoments* arg0, int arg1, int arg2)
{
  return cvGetNormalizedCentralMoment(arg0, arg1, arg2);
}

void Pure_cvGetHuMoments(CvMoments* arg0, CvHuMoments* arg1)
{
  return cvGetHuMoments(arg0, arg1);
}

int Pure_cvSampleLine(void const* arg0, CvPoint* arg1, CvPoint* arg2, void* arg3, int arg4)
{
  return cvSampleLine(arg0, *arg1, *arg2, arg3, arg4);
}

void Pure_cvGetRectSubPix(void const* arg0, void* arg1, CvPoint2D32f* arg2)
{
  return cvGetRectSubPix(arg0, arg1, *arg2);
}

void Pure_cvGetQuadrangleSubPix(void const* arg0, void* arg1, CvMat const* arg2)
{
  return cvGetQuadrangleSubPix(arg0, arg1, arg2);
}

void Pure_cvMatchTemplate(void const* arg0, void const* arg1, void* arg2, int arg3)
{
  return cvMatchTemplate(arg0, arg1, arg2, arg3);
}

float Pure_cvCalcEMD2(void const* arg0, void const* arg1, int arg2, void* arg3, void const* arg4, void* arg5, float* arg6, void* arg7)
{
  return cvCalcEMD2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}

int Pure_cvFindContours(void* arg0, CvMemStorage* arg1, CvSeq** arg2, int arg3, int arg4, int arg5, CvPoint* arg6)
{
  return cvFindContours(arg0, arg1, arg2, arg3, arg4, arg5, *arg6);
}

struct _CvContourScanner* Pure_cvStartFindContours(void* arg0, CvMemStorage* arg1, int arg2, int arg3, int arg4, CvPoint* arg5)
{
  return cvStartFindContours(arg0, arg1, arg2, arg3, arg4, *arg5);
}

CvSeq* Pure_cvFindNextContour(struct _CvContourScanner* arg0)
{
  return cvFindNextContour(arg0);
}

void Pure_cvSubstituteContour(struct _CvContourScanner* arg0, CvSeq* arg1)
{
  return cvSubstituteContour(arg0, arg1);
}

CvSeq* Pure_cvEndFindContours(struct _CvContourScanner** arg0)
{
  return cvEndFindContours(arg0);
}

CvSeq* Pure_cvApproxChains(CvSeq* arg0, CvMemStorage* arg1, int arg2, double arg3, int arg4, int arg5)
{
  return cvApproxChains(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvStartReadChainPoints(CvChain* arg0, CvChainPtReader* arg1)
{
  return cvStartReadChainPoints(arg0, arg1);
}

CvPoint* Pure_cvReadChainPoint(CvChainPtReader* arg0)
{
  static CvPoint ret;
  ret = cvReadChainPoint(arg0); return &ret;
}

void Pure_cvCalcOpticalFlowLK(void const* arg0, void const* arg1, CvSize* arg2, void* arg3, void* arg4)
{
  return cvCalcOpticalFlowLK(arg0, arg1, *arg2, arg3, arg4);
}

void Pure_cvCalcOpticalFlowBM(void const* arg0, void const* arg1, CvSize* arg2, CvSize* arg3, CvSize* arg4, int arg5, void* arg6, void* arg7)
{
  return cvCalcOpticalFlowBM(arg0, arg1, *arg2, *arg3, *arg4, arg5, arg6, arg7);
}

void Pure_cvCalcOpticalFlowHS(void const* arg0, void const* arg1, int arg2, void* arg3, void* arg4, double arg5, CvTermCriteria* arg6)
{
  return cvCalcOpticalFlowHS(arg0, arg1, arg2, arg3, arg4, arg5, *arg6);
}

void Pure_cvCalcOpticalFlowPyrLK(void const* arg0, void const* arg1, void* arg2, void* arg3, CvPoint2D32f const* arg4, CvPoint2D32f* arg5, int arg6, CvSize* arg7, int arg8, char* arg9, float* arg10, CvTermCriteria* arg11, int arg12)
{
  return cvCalcOpticalFlowPyrLK(arg0, arg1, arg2, arg3, arg4, arg5, arg6, *arg7, arg8, arg9, arg10, *arg11, arg12);
}

void Pure_cvCalcAffineFlowPyrLK(void const* arg0, void const* arg1, void* arg2, void* arg3, CvPoint2D32f const* arg4, CvPoint2D32f* arg5, float* arg6, int arg7, CvSize* arg8, int arg9, char* arg10, float* arg11, CvTermCriteria* arg12, int arg13)
{
  return cvCalcAffineFlowPyrLK(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, *arg8, arg9, arg10, arg11, *arg12, arg13);
}

int Pure_cvEstimateRigidTransform(void const* arg0, void const* arg1, CvMat* arg2, int arg3)
{
  return cvEstimateRigidTransform(arg0, arg1, arg2, arg3);
}

void Pure_cvUpdateMotionHistory(void const* arg0, void* arg1, double arg2, double arg3)
{
  return cvUpdateMotionHistory(arg0, arg1, arg2, arg3);
}

void Pure_cvCalcMotionGradient(void const* arg0, void* arg1, void* arg2, double arg3, double arg4, int arg5)
{
  return cvCalcMotionGradient(arg0, arg1, arg2, arg3, arg4, arg5);
}

double Pure_cvCalcGlobalOrientation(void const* arg0, void const* arg1, void const* arg2, double arg3, double arg4)
{
  return cvCalcGlobalOrientation(arg0, arg1, arg2, arg3, arg4);
}

CvSeq* Pure_cvSegmentMotion(void const* arg0, void* arg1, CvMemStorage* arg2, double arg3, double arg4)
{
  return cvSegmentMotion(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvAcc(void const* arg0, void* arg1, void const* arg2)
{
  return cvAcc(arg0, arg1, arg2);
}

void Pure_cvSquareAcc(void const* arg0, void* arg1, void const* arg2)
{
  return cvSquareAcc(arg0, arg1, arg2);
}

void Pure_cvMultiplyAcc(void const* arg0, void const* arg1, void* arg2, void const* arg3)
{
  return cvMultiplyAcc(arg0, arg1, arg2, arg3);
}

void Pure_cvRunningAvg(void const* arg0, void* arg1, double arg2, void const* arg3)
{
  return cvRunningAvg(arg0, arg1, arg2, arg3);
}

int Pure_cvCamShift(void const* arg0, CvRect* arg1, CvTermCriteria* arg2, CvConnectedComp* arg3, CvBox2D* arg4)
{
  return cvCamShift(arg0, *arg1, *arg2, arg3, arg4);
}

int Pure_cvMeanShift(void const* arg0, CvRect* arg1, CvTermCriteria* arg2, CvConnectedComp* arg3)
{
  return cvMeanShift(arg0, *arg1, *arg2, arg3);
}

CvConDensation* Pure_cvCreateConDensation(int arg0, int arg1, int arg2)
{
  return cvCreateConDensation(arg0, arg1, arg2);
}

void Pure_cvReleaseConDensation(CvConDensation** arg0)
{
  return cvReleaseConDensation(arg0);
}

void Pure_cvConDensUpdateByTime(CvConDensation* arg0)
{
  return cvConDensUpdateByTime(arg0);
}

void Pure_cvConDensInitSampleSet(CvConDensation* arg0, CvMat* arg1, CvMat* arg2)
{
  return cvConDensInitSampleSet(arg0, arg1, arg2);
}

CvKalman* Pure_cvCreateKalman(int arg0, int arg1, int arg2)
{
  return cvCreateKalman(arg0, arg1, arg2);
}

void Pure_cvReleaseKalman(CvKalman** arg0)
{
  return cvReleaseKalman(arg0);
}

CvMat const* Pure_cvKalmanPredict(CvKalman* arg0, CvMat const* arg1)
{
  return cvKalmanPredict(arg0, arg1);
}

CvMat const* Pure_cvKalmanCorrect(CvKalman* arg0, CvMat const* arg1)
{
  return cvKalmanCorrect(arg0, arg1);
}

void Pure_cvInitSubdivDelaunay2D(CvSubdiv2D* arg0, CvRect* arg1)
{
  return cvInitSubdivDelaunay2D(arg0, *arg1);
}

CvSubdiv2D* Pure_cvCreateSubdiv2D(int arg0, int arg1, int arg2, int arg3, CvMemStorage* arg4)
{
  return cvCreateSubdiv2D(arg0, arg1, arg2, arg3, arg4);
}

CvSubdiv2DPoint* Pure_cvSubdivDelaunay2DInsert(CvSubdiv2D* arg0, CvPoint2D32f* arg1)
{
  return cvSubdivDelaunay2DInsert(arg0, *arg1);
}

int Pure_cvSubdiv2DLocate(CvSubdiv2D* arg0, CvPoint2D32f* arg1, unsigned int* arg2, CvSubdiv2DPoint** arg3)
{
  return cvSubdiv2DLocate(arg0, *arg1, arg2, arg3);
}

void Pure_cvCalcSubdivVoronoi2D(CvSubdiv2D* arg0)
{
  return cvCalcSubdivVoronoi2D(arg0);
}

void Pure_cvClearSubdivVoronoi2D(CvSubdiv2D* arg0)
{
  return cvClearSubdivVoronoi2D(arg0);
}

CvSubdiv2DPoint* Pure_cvFindNearestPoint2D(CvSubdiv2D* arg0, CvPoint2D32f* arg1)
{
  return cvFindNearestPoint2D(arg0, *arg1);
}

CvSeq* Pure_cvApproxPoly(void const* arg0, int arg1, CvMemStorage* arg2, int arg3, double arg4, int arg5)
{
  return cvApproxPoly(arg0, arg1, arg2, arg3, arg4, arg5);
}

CvSeq* Pure_cvFindDominantPoints(CvSeq* arg0, CvMemStorage* arg1, int arg2, double arg3, double arg4, double arg5, double arg6)
{
  return cvFindDominantPoints(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

double Pure_cvArcLength(void const* arg0, CvSlice* arg1, int arg2)
{
  return cvArcLength(arg0, *arg1, arg2);
}

CvRect* Pure_cvBoundingRect(void* arg0, int arg1)
{
  static CvRect ret;
  ret = cvBoundingRect(arg0, arg1); return &ret;
}

double Pure_cvContourArea(void const* arg0, CvSlice* arg1)
{
  return cvContourArea(arg0, *arg1);
}

CvBox2D* Pure_cvMinAreaRect2(void const* arg0, CvMemStorage* arg1)
{
  static CvBox2D ret;
  ret = cvMinAreaRect2(arg0, arg1); return &ret;
}

int Pure_cvMinEnclosingCircle(void const* arg0, CvPoint2D32f* arg1, float* arg2)
{
  return cvMinEnclosingCircle(arg0, arg1, arg2);
}

double Pure_cvMatchShapes(void const* arg0, void const* arg1, int arg2, double arg3)
{
  return cvMatchShapes(arg0, arg1, arg2, arg3);
}

CvContourTree* Pure_cvCreateContourTree(CvSeq const* arg0, CvMemStorage* arg1, double arg2)
{
  return cvCreateContourTree(arg0, arg1, arg2);
}

CvSeq* Pure_cvContourFromContourTree(CvContourTree const* arg0, CvMemStorage* arg1, CvTermCriteria* arg2)
{
  return cvContourFromContourTree(arg0, arg1, *arg2);
}

double Pure_cvMatchContourTrees(CvContourTree const* arg0, CvContourTree const* arg1, int arg2, double arg3)
{
  return cvMatchContourTrees(arg0, arg1, arg2, arg3);
}

void Pure_cvCalcPGH(CvSeq const* arg0, CvHistogram* arg1)
{
  return cvCalcPGH(arg0, arg1);
}

CvSeq* Pure_cvConvexHull2(void const* arg0, void* arg1, int arg2, int arg3)
{
  return cvConvexHull2(arg0, arg1, arg2, arg3);
}

int Pure_cvCheckContourConvexity(void const* arg0)
{
  return cvCheckContourConvexity(arg0);
}

CvSeq* Pure_cvConvexityDefects(void const* arg0, void const* arg1, CvMemStorage* arg2)
{
  return cvConvexityDefects(arg0, arg1, arg2);
}

CvBox2D* Pure_cvFitEllipse2(void const* arg0)
{
  static CvBox2D ret;
  ret = cvFitEllipse2(arg0); return &ret;
}

CvRect* Pure_cvMaxRect(CvRect const* arg0, CvRect const* arg1)
{
  static CvRect ret;
  ret = cvMaxRect(arg0, arg1); return &ret;
}

void Pure_cvBoxPoints(CvBox2D* arg0, CvPoint2D32f* arg1)
{
  return cvBoxPoints(*arg0, arg1);
}

CvSeq* Pure_cvPointSeqFromMat(int arg0, void const* arg1, CvContour* arg2, CvSeqBlock* arg3)
{
  return cvPointSeqFromMat(arg0, arg1, arg2, arg3);
}

double Pure_cvPointPolygonTest(void const* arg0, CvPoint2D32f* arg1, int arg2)
{
  return cvPointPolygonTest(arg0, *arg1, arg2);
}

CvHistogram* Pure_cvCreateHist(int arg0, int* arg1, int arg2, float** arg3, int arg4)
{
  return cvCreateHist(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvSetHistBinRanges(CvHistogram* arg0, float** arg1, int arg2)
{
  return cvSetHistBinRanges(arg0, arg1, arg2);
}

CvHistogram* Pure_cvMakeHistHeaderForArray(int arg0, int* arg1, CvHistogram* arg2, float* arg3, float** arg4, int arg5)
{
  return cvMakeHistHeaderForArray(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvReleaseHist(CvHistogram** arg0)
{
  return cvReleaseHist(arg0);
}

void Pure_cvClearHist(CvHistogram* arg0)
{
  return cvClearHist(arg0);
}

void Pure_cvGetMinMaxHistValue(CvHistogram const* arg0, float* arg1, float* arg2, int* arg3, int* arg4)
{
  return cvGetMinMaxHistValue(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvNormalizeHist(CvHistogram* arg0, double arg1)
{
  return cvNormalizeHist(arg0, arg1);
}

void Pure_cvThreshHist(CvHistogram* arg0, double arg1)
{
  return cvThreshHist(arg0, arg1);
}

double Pure_cvCompareHist(CvHistogram const* arg0, CvHistogram const* arg1, int arg2)
{
  return cvCompareHist(arg0, arg1, arg2);
}

void Pure_cvCopyHist(CvHistogram const* arg0, CvHistogram** arg1)
{
  return cvCopyHist(arg0, arg1);
}

void Pure_cvCalcBayesianProb(CvHistogram** arg0, int arg1, CvHistogram** arg2)
{
  return cvCalcBayesianProb(arg0, arg1, arg2);
}

void Pure_cvCalcArrHist(void** arg0, CvHistogram* arg1, int arg2, void const* arg3)
{
  return cvCalcArrHist(arg0, arg1, arg2, arg3);
}

void Pure_cvCalcArrBackProject(void** arg0, void* arg1, CvHistogram const* arg2)
{
  return cvCalcArrBackProject(arg0, arg1, arg2);
}

void Pure_cvCalcArrBackProjectPatch(void** arg0, void* arg1, CvSize* arg2, CvHistogram* arg3, int arg4, double arg5)
{
  return cvCalcArrBackProjectPatch(arg0, arg1, *arg2, arg3, arg4, arg5);
}

void Pure_cvCalcProbDensity(CvHistogram const* arg0, CvHistogram const* arg1, CvHistogram* arg2, double arg3)
{
  return cvCalcProbDensity(arg0, arg1, arg2, arg3);
}

void Pure_cvEqualizeHist(void const* arg0, void* arg1)
{
  return cvEqualizeHist(arg0, arg1);
}

void Pure_cvSnakeImage(IplImage const* arg0, CvPoint* arg1, int arg2, float* arg3, float* arg4, float* arg5, int arg6, CvSize* arg7, CvTermCriteria* arg8, int arg9)
{
  return cvSnakeImage(arg0, arg1, arg2, arg3, arg4, arg5, arg6, *arg7, *arg8, arg9);
}

void Pure_cvCalcImageHomography(float* arg0, CvPoint3D32f* arg1, float* arg2, float* arg3)
{
  return cvCalcImageHomography(arg0, arg1, arg2, arg3);
}

void Pure_cvDistTransform(void const* arg0, void* arg1, int arg2, int arg3, float const* arg4, void* arg5)
{
  return cvDistTransform(arg0, arg1, arg2, arg3, arg4, arg5);
}

double Pure_cvThreshold(void const* arg0, void* arg1, double arg2, double arg3, int arg4)
{
  return cvThreshold(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvAdaptiveThreshold(void const* arg0, void* arg1, double arg2, int arg3, int arg4, int arg5, double arg6)
{
  return cvAdaptiveThreshold(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvFloodFill(void* arg0, CvPoint* arg1, CvScalar* arg2, CvScalar* arg3, CvScalar* arg4, CvConnectedComp* arg5, int arg6, void* arg7)
{
  return cvFloodFill(arg0, *arg1, *arg2, *arg3, *arg4, arg5, arg6, arg7);
}

void Pure_cvCanny(void const* arg0, void* arg1, double arg2, double arg3, int arg4)
{
  return cvCanny(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvPreCornerDetect(void const* arg0, void* arg1, int arg2)
{
  return cvPreCornerDetect(arg0, arg1, arg2);
}

void Pure_cvCornerEigenValsAndVecs(void const* arg0, void* arg1, int arg2, int arg3)
{
  return cvCornerEigenValsAndVecs(arg0, arg1, arg2, arg3);
}

void Pure_cvCornerMinEigenVal(void const* arg0, void* arg1, int arg2, int arg3)
{
  return cvCornerMinEigenVal(arg0, arg1, arg2, arg3);
}

void Pure_cvCornerHarris(void const* arg0, void* arg1, int arg2, int arg3, double arg4)
{
  return cvCornerHarris(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvFindCornerSubPix(void const* arg0, CvPoint2D32f* arg1, int arg2, CvSize* arg3, CvSize* arg4, CvTermCriteria* arg5)
{
  return cvFindCornerSubPix(arg0, arg1, arg2, *arg3, *arg4, *arg5);
}

void Pure_cvGoodFeaturesToTrack(void const* arg0, void* arg1, void* arg2, CvPoint2D32f* arg3, int* arg4, double arg5, double arg6, void const* arg7, int arg8, int arg9, double arg10)
{
  return cvGoodFeaturesToTrack(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
}

CvSeq* Pure_cvHoughLines2(void* arg0, void* arg1, int arg2, double arg3, double arg4, int arg5, double arg6, double arg7)
{
  return cvHoughLines2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}

CvSeq* Pure_cvHoughCircles(void* arg0, void* arg1, int arg2, double arg3, double arg4, double arg5, double arg6, int arg7, int arg8)
{
  return cvHoughCircles(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

void Pure_cvFitLine(void const* arg0, int arg1, double arg2, double arg3, double arg4, float* arg5)
{
  return cvFitLine(arg0, arg1, arg2, arg3, arg4, arg5);
}

struct CvFeatureTree* Pure_cvCreateKDTree(CvMat* arg0)
{
  return cvCreateKDTree(arg0);
}

struct CvFeatureTree* Pure_cvCreateSpillTree(CvMat const* arg0, int const arg1, double const arg2, double const arg3)
{
  return cvCreateSpillTree(arg0, arg1, arg2, arg3);
}

void Pure_cvReleaseFeatureTree(struct CvFeatureTree* arg0)
{
  return cvReleaseFeatureTree(arg0);
}

void Pure_cvFindFeatures(struct CvFeatureTree* arg0, CvMat const* arg1, CvMat* arg2, CvMat* arg3, int arg4, int arg5)
{
  return cvFindFeatures(arg0, arg1, arg2, arg3, arg4, arg5);
}

int Pure_cvFindFeaturesBoxed(struct CvFeatureTree* arg0, CvMat* arg1, CvMat* arg2, CvMat* arg3)
{
  return cvFindFeaturesBoxed(arg0, arg1, arg2, arg3);
}

struct CvLSH* Pure_cvCreateLSH(struct CvLSHOperations* arg0, int arg1, int arg2, int arg3, int arg4, double arg5, long long arg6)
{
  return cvCreateLSH(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

struct CvLSH* Pure_cvCreateMemoryLSH(int arg0, int arg1, int arg2, int arg3, int arg4, double arg5, long long arg6)
{
  return cvCreateMemoryLSH(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvReleaseLSH(struct CvLSH** arg0)
{
  return cvReleaseLSH(arg0);
}

void Pure_cvLSHAdd(struct CvLSH* arg0, CvMat const* arg1, CvMat* arg2)
{
  return cvLSHAdd(arg0, arg1, arg2);
}

void Pure_cvLSHRemove(struct CvLSH* arg0, CvMat const* arg1)
{
  return cvLSHRemove(arg0, arg1);
}

void Pure_cvLSHQuery(struct CvLSH* arg0, CvMat const* arg1, CvMat* arg2, CvMat* arg3, int arg4, int arg5)
{
  return cvLSHQuery(arg0, arg1, arg2, arg3, arg4, arg5);
}

CvSURFParams* Pure_cvSURFParams(double arg0, int arg1)
{
  static CvSURFParams ret;
  ret = cvSURFParams(arg0, arg1); return &ret;
}

void Pure_cvExtractSURF(void const* arg0, void const* arg1, CvSeq** arg2, CvSeq** arg3, CvMemStorage* arg4, CvSURFParams* arg5, int arg6)
{
  return cvExtractSURF(arg0, arg1, arg2, arg3, arg4, *arg5, arg6);
}

CvMSERParams* Pure_cvMSERParams(int arg0, int arg1, int arg2, float arg3, float arg4, int arg5, double arg6, double arg7, int arg8)
{
  static CvMSERParams ret;
  ret = cvMSERParams(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8); return &ret;
}

void Pure_cvExtractMSER(void* arg0, void* arg1, CvSeq** arg2, CvMemStorage* arg3, CvMSERParams* arg4)
{
  return cvExtractMSER(arg0, arg1, arg2, arg3, *arg4);
}

CvSeq* Pure_cvGetStarKeypoints(void const* arg0, CvMemStorage* arg1, CvStarDetectorParams* arg2)
{
  return cvGetStarKeypoints(arg0, arg1, *arg2);
}

CvHaarClassifierCascade* Pure_cvLoadHaarClassifierCascade(char const* arg0, CvSize* arg1)
{
  return cvLoadHaarClassifierCascade(arg0, *arg1);
}

void Pure_cvReleaseHaarClassifierCascade(CvHaarClassifierCascade** arg0)
{
  return cvReleaseHaarClassifierCascade(arg0);
}

CvSeq* Pure_cvHaarDetectObjects(void const* arg0, CvHaarClassifierCascade* arg1, CvMemStorage* arg2, double arg3, int arg4, int arg5, CvSize* arg6)
{
  return cvHaarDetectObjects(arg0, arg1, arg2, arg3, arg4, arg5, *arg6);
}

void Pure_cvSetImagesForHaarClassifierCascade(CvHaarClassifierCascade* arg0, void const* arg1, void const* arg2, void const* arg3, double arg4)
{
  return cvSetImagesForHaarClassifierCascade(arg0, arg1, arg2, arg3, arg4);
}

int Pure_cvRunHaarClassifierCascade(CvHaarClassifierCascade const* arg0, CvPoint* arg1, int arg2)
{
  return cvRunHaarClassifierCascade(arg0, *arg1, arg2);
}

void Pure_cvUndistort2(void const* arg0, void* arg1, CvMat const* arg2, CvMat const* arg3)
{
  return cvUndistort2(arg0, arg1, arg2, arg3);
}

void Pure_cvInitUndistortMap(CvMat const* arg0, CvMat const* arg1, void* arg2, void* arg3)
{
  return cvInitUndistortMap(arg0, arg1, arg2, arg3);
}

void Pure_cvInitUndistortRectifyMap(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvMat const* arg3, void* arg4, void* arg5)
{
  return cvInitUndistortRectifyMap(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvUndistortPoints(CvMat const* arg0, CvMat* arg1, CvMat const* arg2, CvMat const* arg3, CvMat const* arg4, CvMat const* arg5)
{
  return cvUndistortPoints(arg0, arg1, arg2, arg3, arg4, arg5);
}

int Pure_cvRodrigues2(CvMat const* arg0, CvMat* arg1, CvMat* arg2)
{
  return cvRodrigues2(arg0, arg1, arg2);
}

int Pure_cvFindHomography(CvMat const* arg0, CvMat const* arg1, CvMat* arg2, int arg3, double arg4, CvMat* arg5)
{
  return cvFindHomography(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvRQDecomp3x3(CvMat const* arg0, CvMat* arg1, CvMat* arg2, CvMat* arg3, CvMat* arg4, CvMat* arg5, CvPoint3D64f* arg6)
{
  return cvRQDecomp3x3(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvDecomposeProjectionMatrix(CvMat const* arg0, CvMat* arg1, CvMat* arg2, CvMat* arg3, CvMat* arg4, CvMat* arg5, CvMat* arg6, CvPoint3D64f* arg7)
{
  return cvDecomposeProjectionMatrix(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
}

void Pure_cvCalcMatMulDeriv(CvMat const* arg0, CvMat const* arg1, CvMat* arg2, CvMat* arg3)
{
  return cvCalcMatMulDeriv(arg0, arg1, arg2, arg3);
}

void Pure_cvComposeRT(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvMat const* arg3, CvMat* arg4, CvMat* arg5, CvMat* arg6, CvMat* arg7, CvMat* arg8, CvMat* arg9, CvMat* arg10, CvMat* arg11, CvMat* arg12, CvMat* arg13)
{
  return cvComposeRT(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
}

void Pure_cvProjectPoints2(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvMat const* arg3, CvMat const* arg4, CvMat* arg5, CvMat* arg6, CvMat* arg7, CvMat* arg8, CvMat* arg9, CvMat* arg10, double arg11)
{
  return cvProjectPoints2(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
}

void Pure_cvFindExtrinsicCameraParams2(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvMat const* arg3, CvMat* arg4, CvMat* arg5, int arg6)
{
  return cvFindExtrinsicCameraParams2(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvInitIntrinsicParams2D(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvSize* arg3, CvMat* arg4, double arg5)
{
  return cvInitIntrinsicParams2D(arg0, arg1, arg2, *arg3, arg4, arg5);
}

int Pure_cvFindChessboardCorners(void const* arg0, CvSize* arg1, CvPoint2D32f* arg2, int* arg3, int arg4)
{
  return cvFindChessboardCorners(arg0, *arg1, arg2, arg3, arg4);
}

void Pure_cvDrawChessboardCorners(void* arg0, CvSize* arg1, CvPoint2D32f* arg2, int arg3, int arg4)
{
  return cvDrawChessboardCorners(arg0, *arg1, arg2, arg3, arg4);
}

void Pure_cvCalibrateCamera2(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvSize* arg3, CvMat* arg4, CvMat* arg5, CvMat* arg6, CvMat* arg7, int arg8)
{
  return cvCalibrateCamera2(arg0, arg1, arg2, *arg3, arg4, arg5, arg6, arg7, arg8);
}

void Pure_cvCalibrationMatrixValues(CvMat const* arg0, CvSize* arg1, double arg2, double arg3, double* arg4, double* arg5, double* arg6, CvPoint2D64f* arg7, double* arg8)
{
  return cvCalibrationMatrixValues(arg0, *arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
}

void Pure_cvStereoCalibrate(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvMat const* arg3, CvMat* arg4, CvMat* arg5, CvMat* arg6, CvMat* arg7, CvSize* arg8, CvMat* arg9, CvMat* arg10, CvMat* arg11, CvMat* arg12, CvTermCriteria* arg13, int arg14)
{
  return cvStereoCalibrate(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, *arg8, arg9, arg10, arg11, arg12, *arg13, arg14);
}

void Pure_cvStereoRectify(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvMat const* arg3, CvSize* arg4, CvMat const* arg5, CvMat const* arg6, CvMat* arg7, CvMat* arg8, CvMat* arg9, CvMat* arg10, CvMat* arg11, int arg12)
{
  return cvStereoRectify(arg0, arg1, arg2, arg3, *arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
}

int Pure_cvStereoRectifyUncalibrated(CvMat const* arg0, CvMat const* arg1, CvMat const* arg2, CvSize* arg3, CvMat* arg4, CvMat* arg5, double arg6)
{
  return cvStereoRectifyUncalibrated(arg0, arg1, arg2, *arg3, arg4, arg5, arg6);
}

CvPOSITObject* Pure_cvCreatePOSITObject(CvPoint3D32f* arg0, int arg1)
{
  return cvCreatePOSITObject(arg0, arg1);
}

void Pure_cvPOSIT(CvPOSITObject* arg0, CvPoint2D32f* arg1, double arg2, CvTermCriteria* arg3, float* arg4, float* arg5)
{
  return cvPOSIT(arg0, arg1, arg2, *arg3, arg4, arg5);
}

void Pure_cvReleasePOSITObject(CvPOSITObject** arg0)
{
  return cvReleasePOSITObject(arg0);
}

int Pure_cvRANSACUpdateNumIters(double arg0, double arg1, int arg2, int arg3)
{
  return cvRANSACUpdateNumIters(arg0, arg1, arg2, arg3);
}

void Pure_cvConvertPointsHomogeneous(CvMat const* arg0, CvMat* arg1)
{
  return cvConvertPointsHomogeneous(arg0, arg1);
}

int Pure_cvFindFundamentalMat(CvMat const* arg0, CvMat const* arg1, CvMat* arg2, int arg3, double arg4, double arg5, CvMat* arg6)
{
  return cvFindFundamentalMat(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
}

void Pure_cvComputeCorrespondEpilines(CvMat const* arg0, int arg1, CvMat const* arg2, CvMat* arg3)
{
  return cvComputeCorrespondEpilines(arg0, arg1, arg2, arg3);
}

void Pure_cvTriangulatePoints(CvMat* arg0, CvMat* arg1, CvMat* arg2, CvMat* arg3, CvMat* arg4)
{
  return cvTriangulatePoints(arg0, arg1, arg2, arg3, arg4);
}

void Pure_cvCorrectMatches(CvMat* arg0, CvMat* arg1, CvMat* arg2, CvMat* arg3, CvMat* arg4)
{
  return cvCorrectMatches(arg0, arg1, arg2, arg3, arg4);
}

CvStereoBMState* Pure_cvCreateStereoBMState(int arg0, int arg1)
{
  return cvCreateStereoBMState(arg0, arg1);
}

void Pure_cvReleaseStereoBMState(CvStereoBMState** arg0)
{
  return cvReleaseStereoBMState(arg0);
}

void Pure_cvFindStereoCorrespondenceBM(void const* arg0, void const* arg1, void* arg2, CvStereoBMState* arg3)
{
  return cvFindStereoCorrespondenceBM(arg0, arg1, arg2, arg3);
}

CvStereoGCState* Pure_cvCreateStereoGCState(int arg0, int arg1)
{
  return cvCreateStereoGCState(arg0, arg1);
}

void Pure_cvReleaseStereoGCState(CvStereoGCState** arg0)
{
  return cvReleaseStereoGCState(arg0);
}

void Pure_cvFindStereoCorrespondenceGC(void const* arg0, void const* arg1, void* arg2, void* arg3, CvStereoGCState* arg4, int arg5)
{
  return cvFindStereoCorrespondenceGC(arg0, arg1, arg2, arg3, arg4, arg5);
}

void Pure_cvReprojectImageTo3D(void const* arg0, void* arg1, CvMat const* arg2, int arg3)
{
  return cvReprojectImageTo3D(arg0, arg1, arg2, arg3);
}
#include "c:/Opt/OpenCV2.0/include/opencv/highgui.h"
#include "c:/Opt/OpenCV2.0/include/opencv/highgui.h"

IplImage* Pure_cvLoadImage(char const* arg0, int arg1)
{
  return cvLoadImage(arg0, arg1);
}

CvMat* Pure_cvLoadImageM(char const* arg0, int arg1)
{
  return cvLoadImageM(arg0, arg1);
}

int Pure_cvSaveImage(char const* arg0, void const* arg1, int const* arg2)
{
  return cvSaveImage(arg0, arg1, arg2);
}
